package com.Thread;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Description 线程串行化
 * @Author Weseave
 * @Date 2023/2/21 15:16
 * @Version 1.0
 */
public class CompletableFutureStudy02 {

    public static final ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        /**
         * 1. thenRunAsync
         *  不能获取到上一步的执行结果，无返回值
         * 2. thenAcceptAsync
         *  可以接受上一个线程的返回值，但是无返回值
         * 3. thenApplyAsync
         *   可以接受上一个线程的返回值，也有返回值
         */
        //1 thenRunAsync
//        CompletableFuture<Void> future1 = CompletableFuture.supplyAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("运行结果：" + i);
//            return i;
//        }, executor).thenRunAsync(()->{
//            System.out.println("任务2启动了");
//        },executor);

        //2 thenAcceptAsync
//        CompletableFuture<Void> future2 = CompletableFuture.supplyAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("运行结果：" + i);
//            return i;
//        }, executor).thenAcceptAsync(result->{
//            System.out.println("任务2启动了..."+result);
//        },executor);

        //3 thenApplyAsync
//        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("运行结果：" + i);
//            return i;
//        }, executor).thenApplyAsync(result->{
//            System.out.println("任务2启动了..."+result);
//            return "hello "+ result;
//        },executor);


        /**
         * 两个都完成
         * 1. runAfterBothAsync
         *  不能感知到前两个线程的结果
         * 2.thenAcceptBothAsync
         *  可以感知到前两个线程的结果
         * 3. thenCombineAsync
         *  可以感知前两个线程的结果，然后返回自己的结果
         */

//        CompletableFuture<Integer> future4 = CompletableFuture.supplyAsync(() -> {
//            System.out.println("任务1线程：" + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("任务1结束：");
//            return i;
//        }, executor);
//        CompletableFuture<String> future5 = CompletableFuture.supplyAsync(() -> {
//            System.out.println("任务2线程：" + Thread.currentThread().getId());
//            System.out.println("任务2结束：");
//            return "hello";
//        }, executor);
        //1 runAfterBothAsync
//        future4.runAfterBothAsync(future5,()->{
//            System.out.println("任务3开始");
//        },executor);

        //2 thenAcceptBothAsync     void accept(T t,U u)
//        future4.thenAcceptBothAsync(future5,(result1,result2)->{
//            System.out.println("任务3开始.."+"任务1返回值"+result1+"..任务2返回值"+result2);
//        },executor);

        //3thenCombineAsync   R apply(T t,U u)
//        CompletableFuture<String> futureResult = future4.thenCombineAsync(future5, (result1, result2) -> {
//            return result1 + "::" + result2;
//        }, executor);


        /**
         * 两个任务，一个完成就执行其他任务
         * 1. runAfterEitherAsync
         *  不能感知结果，自己也没有返回值
         * 2.acceptEitherAsync
         *  可以感知到结果
         * 3. thenCombineAsync
         *  可以感知到结果，自己也有返回值
         */

        CompletableFuture<Object> future6 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 2;
            System.out.println("任务1结束：");
            return i;
        }, executor);
        CompletableFuture<Object> future7 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
                System.out.println("任务2结束：");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello";
        }, executor);

        //1 runAfterEitherAsync
//        future6.runAfterEitherAsync(future7,()->{
//            System.out.println("任务3开始");
//        },executor);

        //2 acceptEitherAsync     void accept(T t)
//        future6.acceptEitherAsync(future7,result->{
//            System.out.println("任务3开始.."+"任务返回值"+result);
//        },executor);

        //3thenCombineAsync   R apply(T t,U u)
//        CompletableFuture<String> futureResult2 = future6.applyToEitherAsync(future7, result ->result + "::任务3执行", executor);


        /**
         * 多任务组合
         * public static CompletableFuture<void> allOf(CompletebaleFuture<?>...cfs);
         *  等待所有任务完成
         * public static CompletableFuture<Object> anyOf(CompletebaleFuture<?>...cfs);
         *  只要有一个任务完成
         */

    }
}
